// 子弹类（增强特效版）
import { TimeManager } from './TimeManager.js';

export class Bullet {
    constructor(x, y, vx, vy, type, extraData = {}) {
        this.x = x;
        this.y = y;
        this.vx = vx * 60; // 转换为像素/秒（假设原来是60FPS）
        this.vy = vy * 60; // 转换为像素/秒
        this.type = type; // 'player', 'enemy', or 'boss'
        
        // 追踪导弹相关属性
        this.isTracking = extraData.isTracking || false;
        this.wasTracking = this.isTracking; // 记录是否曾经是追踪导弹
        this.targetX = extraData.targetX || 0;
        this.targetY = extraData.targetY || 0;
        this.trackingStrength = extraData.trackingStrength || 0.8;
        // 如果已经是像素/秒单位，不再转换
        this.maxSpeed = extraData.maxSpeed || 120;
        
        // 根据类型设置子弹尺寸
        if (type === 'player') {
            this.width = 4;
            this.height = 8;
        } else if (type === 'boss') {
            this.width = 6;  // BOSS子弹更大
            this.height = 10; // BOSS子弹更大
        } else {
            this.width = 3;  // 敌机子弹更小
            this.height = 6; // 敌机子弹更小
        }
        
        // 特效属性
        this.glowPhase = Math.random() * Math.PI * 2;
        this.glowSpeed = TimeManager.CONSTANTS.BULLET_GLOW_SPEED; // 使用时间常量
        this.trailParticles = []; // 拖尾粒子
        this.maxTrailLength = 8;
        this.pulsePhase = 0;
        
        // 追踪导弹调试
        if (this.isTracking) {
            console.log(`创建追踪导弹: 位置(${this.x}, ${this.y}), 目标(${this.targetX}, ${this.targetY}), 速度(${this.vx}, ${this.vy}), 最大速度: ${this.maxSpeed}`);
        }
    }
    
    update(deltaTime, targetX = null, targetY = null) {
        // 记录轨迹用于拖尾效果
        this.trailParticles.unshift({ x: this.x, y: this.y, life: this.maxTrailLength });
        if (this.trailParticles.length > this.maxTrailLength) {
            this.trailParticles.pop();
        }
        
        // 更新拖尾粒子生命值（基于时间）
        const timeBasedDecay = (deltaTime / 16.67); // 相对于60FPS的时间比例
        this.trailParticles.forEach(particle => {
            particle.life -= timeBasedDecay;
        });
        
        // 清理无效的拖尾粒子（生命值小于等于0）
        this.trailParticles = this.trailParticles.filter(particle => particle.life > 0);
        
        // 追踪导弹逻辑
        if (this.isTracking && targetX !== null && targetY !== null) {
            // 更新目标位置
            this.targetX = targetX;
            this.targetY = targetY;
            
            // 计算朝向目标的方向
            const dx = this.targetX - this.x;
            const dy = this.targetY - this.y;
            const distance = Math.sqrt(dx * dx + dy * dy);
            
            if (distance > 5) { // 避免过度震荡
                // 计算当前速度方向的角度
                const currentAngle = Math.atan2(this.vy, this.vx);
                
                // 计算朝向目标的角度
                const targetAngle = Math.atan2(dy, dx);
                
                // 计算角度差（绝对值）
                let angleDiff = Math.abs(targetAngle - currentAngle);
                
                // 处理角度跨越180度的情况
                if (angleDiff > Math.PI) {
                    angleDiff = 2 * Math.PI - angleDiff;
                }
                
                // 转换为度数进行判断
                const angleDiffDegrees = angleDiff * (180 / Math.PI);
                
                // 如果角度差大于110度，放弃跟踪
                if (angleDiffDegrees > 110) {
                    this.isTracking = false;
                    console.log(`追踪导弹放弃跟踪，角度差: ${angleDiffDegrees.toFixed(1)}°`);
                } else {
                    // 继续跟踪：计算朝向目标的单位向量
                    const targetVx = (dx / distance) * this.maxSpeed;
                    const targetVy = (dy / distance) * this.maxSpeed;
                    
                    // 渐进式追踪：当前速度和目标速度的线性插值
                    const trackingFactor = this.trackingStrength * 1; // 增加追踪响应速度
                    this.vx += (targetVx - this.vx) * trackingFactor * (deltaTime / 1000);
                    this.vy += (targetVy - this.vy) * trackingFactor * (deltaTime / 1000);
                    
                    // 限制最大速度
                    const currentSpeed = Math.sqrt(this.vx * this.vx + this.vy * this.vy);
                    if (currentSpeed > this.maxSpeed) {
                        this.vx = (this.vx / currentSpeed) * this.maxSpeed;
                        this.vy = (this.vy / currentSpeed) * this.maxSpeed;
                    }
                }
            }
        }
        
        // 更新位置（基于时间）
        this.x += this.vx * (deltaTime / 1000);
        this.y += this.vy * (deltaTime / 1000);
        
        // 更新特效（基于时间）
        this.glowPhase = TimeManager.updatePhase(this.glowPhase, deltaTime, this.glowSpeed);
        this.pulsePhase = TimeManager.updatePhase(this.pulsePhase, deltaTime, 18); // 每秒18弧度
    }
    
    render(ctx) {
        ctx.save();
        
        // 绘制拖尾效果
        this.renderTrail(ctx);
        
        // 绘制发光效果
        this.renderGlow(ctx);
        
        // 绘制子弹本体
        this.renderBullet(ctx);
        
        ctx.restore();
    }
    
    renderTrail(ctx) {
        // 拖尾粒子效果
        this.trailParticles.forEach((particle, index) => {
            // 只渲染有效的粒子（生命值大于0）
            if (particle.life <= 0) return;
            
            const alpha = Math.max(0, particle.life / this.maxTrailLength * 0.6);
            const size = Math.max(0, (particle.life / this.maxTrailLength) * 3);
            
            // 如果尺寸太小或透明度太低，则跳过渲染
            if (size < 0.1 || alpha < 0.01) return;
            
            if (this.type === 'player') {
                ctx.fillStyle = `rgba(0, 255, 65, ${alpha})`;
            } else if (this.type === 'boss') {
                // 根据跟踪状态显示不同颜色的拖尾
                if (this.wasTracking && !this.isTracking) {
                    // 失去跟踪的导弹 - 暗红色拖尾
                    ctx.fillStyle = `rgba(204, 51, 0, ${alpha})`;
                } else {
                    // BOSS子弹为橙色（正常或追踪中）
                    ctx.fillStyle = `rgba(255, 165, 0, ${alpha})`;
                }
            } else {
                ctx.fillStyle = `rgba(255, 68, 68, ${alpha})`;
            }
            
            ctx.beginPath();
            ctx.arc(particle.x + this.width/2, particle.y + this.height/2, size, 0, Math.PI * 2);
            ctx.fill();
        });
    }
    
    renderGlow(ctx) {
        // 动态发光效果
        const glowIntensity = 0.8 + Math.sin(this.glowPhase) * 0.4;
        const glowSize = 12 + Math.sin(this.pulsePhase) * 3;
        
        const gradient = ctx.createRadialGradient(
            this.x + this.width/2, this.y + this.height/2, 0,
            this.x + this.width/2, this.y + this.height/2, glowSize
        );
        
        if (this.type === 'player') {
            gradient.addColorStop(0, `rgba(0, 255, 65, ${glowIntensity * 0.8})`);  // 绿色核心
            gradient.addColorStop(0.5, `rgba(0, 255, 65, ${glowIntensity * 0.4})`);
            gradient.addColorStop(1, 'rgba(0, 255, 65, 0)');
        } else if (this.type === 'boss') {
            // 根据跟踪状态显示不同颜色的发光效果
            if (this.wasTracking && !this.isTracking) {
                // 失去跟踪的导弹 - 暗红色发光
                gradient.addColorStop(0, `rgba(204, 51, 0, ${glowIntensity * 0.9})`);
                gradient.addColorStop(0.5, `rgba(204, 51, 0, ${glowIntensity * 0.6})`);
                gradient.addColorStop(1, 'rgba(204, 51, 0, 0)');
            } else {
                // BOSS橙色核心（正常或追踪中）
                gradient.addColorStop(0, `rgba(255, 165, 0, ${glowIntensity * 0.9})`);
                gradient.addColorStop(0.5, `rgba(255, 165, 0, ${glowIntensity * 0.6})`);
                gradient.addColorStop(1, 'rgba(255, 165, 0, 0)');
            }
        } else {
            gradient.addColorStop(0, `rgba(255, 68, 68, ${glowIntensity * 0.8})`);  // 红色核心
            gradient.addColorStop(0.5, `rgba(255, 68, 68, ${glowIntensity * 0.4})`);
            gradient.addColorStop(1, 'rgba(255, 68, 68, 0)');
        }
        
        ctx.fillStyle = gradient;
        ctx.beginPath();
        ctx.arc(this.x + this.width/2, this.y + this.height/2, glowSize, 0, Math.PI * 2);
        ctx.fill();
    }
    
    renderBullet(ctx) {
        // 子弹本体（更精致的形状）
        ctx.shadowBlur = 8;
        
        if (this.type === 'player') {
            // 玩家子弹 - 能量弹形状
            ctx.shadowColor = '#00ff41';
            
            // 外层光晕
            ctx.fillStyle = '#66ff66';
            ctx.fillRect(this.x - 1, this.y - 1, this.width + 2, this.height + 2);
            
            // 内层核心
            ctx.fillStyle = '#00ff41';
            ctx.fillRect(this.x, this.y, this.width, this.height);
            
            // 中心亮点
            ctx.fillStyle = '#ffffff';
            ctx.fillRect(this.x + 1, this.y + 2, 2, 4);
        } else if (this.type === 'boss') {
            // BOSS子弹 - 能量球形状
            // 根据跟踪状态显示不同颜色
            if (this.wasTracking && !this.isTracking) {
                // 失去跟踪的导弹 - 显示为暗红色
                ctx.shadowColor = '#cc3300';
                
                // 外层光晕
                ctx.fillStyle = '#ff6666';
                ctx.fillRect(this.x - 1, this.y - 1, this.width + 2, this.height + 2);
                
                // 内层核心
                ctx.fillStyle = '#cc3300';
                ctx.fillRect(this.x, this.y, this.width, this.height);
                
                // 中心亮点（较暗）
                ctx.fillStyle = '#ffaaaa';
                ctx.fillRect(this.x + 2, this.y + 3, 2, 4);
            } else {
                // 正常BOSS子弹或追踪导弹 - 橙色
                ctx.shadowColor = '#ffa500';
                
                // 外层光晕（更大）
                ctx.fillStyle = '#ffcc66';
                ctx.fillRect(this.x - 1, this.y - 1, this.width + 2, this.height + 2);
                
                // 内层核心
                ctx.fillStyle = '#ffa500';
                ctx.fillRect(this.x, this.y, this.width, this.height);
                
                // 中心亮点（更亮）
                ctx.fillStyle = '#ffffff';
                ctx.fillRect(this.x + 2, this.y + 3, 2, 4);
            }
        } else {
            // 敌机子弹 - 等离子弹形状
            ctx.shadowColor = '#ff4444';
            
            // 外层光晕
            ctx.fillStyle = '#ff6666';
            ctx.fillRect(this.x - 1, this.y - 1, this.width + 2, this.height + 2);
            
            // 内层核心
            ctx.fillStyle = '#ff4444';
            ctx.fillRect(this.x, this.y, this.width, this.height);
            
            // 中心亮点
            ctx.fillStyle = '#ffaaaa';
            ctx.fillRect(this.x + 1, this.y + 2, 2, 4);
        }
        
        ctx.shadowBlur = 0;
    }
}